home *** CD-ROM | disk | FTP | other *** search
/ Komputer for Alle 2002 #4 / K-CD-4-2002.ISO / Empire Earth / EEDemo.exe / Disk1 / Random Map Scripts / Continental / Continental Tiny.rmv < prev    next >
Encoding:
Text File  |  2001-09-27  |  50.0 KB  |  1,569 lines

  1. //////////////////////////////////////////////////////////////////////
  2. //
  3. // Continental Tiny.rmv
  4. //
  5. //
  6. // Copyright (c) 2000, Stainless Steel Studios, Inc. All rights reserved.
  7. // PROPRIETARY and CONFIDENTIAL.
  8. //
  9. // $Creator: Richard Bishop $
  10. // $Date: 9/17/01 6:54p $
  11. // $Revision: 11 $
  12. // $Revision: 11 $Revision: 8
  13. //   Adjusted Angle between team members 
  14. // Revision: 9 
  15. //    Pushed players and outer neutrals toward the map edge
  16. //    increased land, trees, decreased outer neutrals and flat land 
  17. //    Assumes Initial Step = 64 in Continental.rmv
  18. //  Revision: 15 Revised for miniaturization
  19. //  Revision: 16 Elevation 
  20. //  Revision: 17 Revised # of resources 3 by 3
  21. //  Revision: 18 8+ player adjustment and enhanced resource placement 
  22. //  Revision: 19 Resource Distance Tweak
  23. //////////////////////////////////////////////////////////////////////
  24.  
  25. #if            NOTDEFINED(CONTINENTAL_TINY_RMV)
  26. #define        (CONTINENTAL_TINY_RMV,1)
  27.  
  28. //////////////////////////////////////////////////////////////////////
  29. // Definitions we are required to define for continental maps
  30. //////////////////////////////////////////////////////////////////////
  31.  
  32. //////////////////////////////////////////////////////////////////////
  33. // Secondary Resource Placements
  34.  
  35. #if DEFINED(kWinterMap)
  36.   PlaceWorldUnitInRing (Res-Walrus, 11, 11)
  37.   PlaceWorldUnitInRing (Res-Walrus, 11, 11)
  38. #else 
  39.   PlaceWorldUnitInRing (Res-Hippopotamus, 11, 11)
  40.   PlaceWorldUnitInRing (Res-Hippopotamus, 11, 11)
  41. #endif
  42.  
  43. //////////////////////////////////////////////////////////////////////
  44. // Resource
  45.  
  46. //////////////////////////////////////////////////////////////////////
  47. // Resource Limitations
  48. ResourcePlacementLimit (Gold,         8,    9)
  49. ResourcePlacementLimit (Steel,         7,     8)
  50. ResourcePlacementLimit (Berry,         6,    7)
  51. ResourcePlacementLimit (Tree,         3,    5)
  52. ResourcePlacementLimit (Stone,         11,    12)
  53.  
  54. #if Is2Players
  55. //////////////////////////////////////////////////////////////////////
  56. // 2 PLAYERS...
  57. //////////////////////////////////////////////////////////////////////
  58.  
  59. PlaceResourceInRing (Gold, 14, 16)
  60. PlaceResourceInRing (Iron, 15, 17)
  61.  
  62. //////////////////////////////////////////////////////////////////////
  63. // terrain definitions
  64. HeightMapSmoothness                    0)
  65. #define        (kMinIntElevation,            -10)
  66. #define        (kMaxIntElevation,            10)
  67. #define        (kElevationScale,                0.7)
  68. #define        (kPercentLand,                Between(.72, .72))
  69. #define        (kWaterBorder,                6)
  70. #define        (kHeightMapChaos,                Between(8, 15))
  71.                                             
  72. #define        (kMinimumStartPositionToMapEdge        1)
  73. #define        (kOuterPushFromMapCenter        24)
  74. #define        (kInnerPushFromMapCenter         0)
  75.  
  76. //////////////////////////////////////////////////////////////////////
  77. // player definitions
  78. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  79. #define        (kPlayerInnerRadius,            0.8)
  80. #define        (kPlayerOuterRadius,            0.99)
  81. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  82. #define        (kPlayerPercentFlat,            Between(0.94, 0.94))
  83. #define        (kPlayerLandChaos,            0.8)
  84. #define        (kPlayerLandClumps,            1)
  85. #define        (kPlayerFlatChaos,            0.8)
  86. #define        (kPlayerFlatClumps,            2)
  87. #define        (kPlayerTreePercentage,            0.1)
  88.  
  89.  
  90. //////////////////////////////////////////////////////////////////////
  91. // inner neutral definitions
  92. #define        (kNeutralInnerRadius,            0.34)
  93. #define        (kNeutralOuterRadius,            0.55)
  94. #define        (kNeutralOptimalFactor,            0.7)
  95. #define        (kNumInnerNeutrals,            Between(4, 4))
  96. #define        (kInnerNeutralPercentLand,        0.3)
  97. #define        (kInnerNeutralPercentFlat,        0.9)
  98. #define        (kInnerNeutralTreePercentage,          0.1)
  99. #define        (kInnerNeutralLandChaos,        0.9)
  100. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  101. #define        (kInnerNeutralFlatChaos,        0.8)
  102. #define        (kInnerNeutralFlatClumps,        1)
  103.  
  104.  
  105. //////////////////////////////////////////////////////////////////////
  106. // outer neutral definitions
  107. #define        (kNumOuterNeutrals,            15)
  108. #define        (kOuterNeutralPercentLand,        0.5)
  109. #define        (kOuterNeutralPercentFlat,        0.8)
  110. #define        (kOuterNeutralTreePercentage,          0.1)
  111. #define        (kOuterNeutralLandChaos,        0.8)
  112. #define        (kOuterNeutralLandClumps,        2)
  113. #define        (kOuterNeutralFlatChaos,        0.8)
  114. #define        (kOuterNeutralFlatClumps,        1)
  115.  
  116.  
  117. //////////////////////////////////////////////////////////////////////
  118. // resource definitions
  119. #define        (kMaxResourceElevation,            2)
  120. #define        (kResourceToEdgeDistance,        1)
  121. #define        (kResourceToWaterDistance,        1)
  122.  
  123. #define        (kAnimalPerPlayer,            0)
  124. #define        (kAnimalPerNeutral,            0)
  125.  
  126. #if (IsPaleoEpoch) 
  127.   #define  (kBerryPerPlayer,    2)
  128. #else
  129.   #define  (kBerryPerPlayer,    1)
  130. #endif
  131.  
  132. #define        (kBerryPerNeutral,                0)
  133.  
  134. #define        (kFishPerPlayer,                5)
  135. #define        (kFishPerNeutral,                24)
  136.  
  137. #define        (kGoldPerPlayer,                1)
  138. #define        (kGoldPerNeutral,                2)
  139.  
  140. #define        (kOilPerPlayer,                    0)
  141. #define        (kOilPerNeutral,                0)
  142.  
  143. #define        (kSteelPerPlayer,                1)
  144. #define        (kSteelPerNeutral,                2)
  145.  
  146. #define        (kStonePerPlayer,                1)
  147. #define        (kStonePerNeutral,                2)
  148.  
  149. #define        (kTreePerPlayer,                0)
  150. #define        (kTreePerNeutral,                0)
  151.  
  152.  
  153. //////////////////////////////////////////////////////////////////////
  154. // forest definitions
  155. #define        (kForestFreeRadius,            7.0)
  156. #define        (kForestsPerPlayer,            1)
  157. #define        (kForestChaosLevel,            0.1)
  158. #define        (kMaxClumpsPerForest,              2)
  159.  
  160.  
  161. #elif Is3Players
  162. //////////////////////////////////////////////////////////////////////
  163. // 3 PLAYERS...
  164. //////////////////////////////////////////////////////////////////////
  165.  
  166. PlaceResourceInRing (Gold, 12, 14)
  167. PlaceResourceInRing (Iron, 12, 14)
  168.  
  169. //////////////////////////////////////////////////////////////////////
  170. // terrain definitions
  171. HeightMapSmoothness                    0)
  172. #define        (kMinIntElevation,            -10)
  173. #define        (kMaxIntElevation,            10)
  174. #define        (kElevationScale,                0.7)
  175. #define        (kPercentLand,                Between(.73, .73))
  176. #define        (kWaterBorder,                6)
  177. #define        (kHeightMapChaos,            Between(8, 15))
  178.                                             
  179. #define        (kMinimumStartPositionToMapEdge        1)
  180. #define        (kOuterPushFromMapCenter        24)
  181. #define        (kInnerPushFromMapCenter         0)
  182.  
  183. //////////////////////////////////////////////////////////////////////
  184. // player definitions
  185. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  186. #define        (kPlayerInnerRadius,            0.8)
  187. #define        (kPlayerOuterRadius,            0.99)
  188. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  189. #define        (kPlayerPercentFlat,            Between(0.94, 0.94))
  190. #define        (kPlayerLandChaos,            0.8)
  191. #define        (kPlayerLandClumps,            1)
  192. #define        (kPlayerFlatChaos,            0.8)
  193. #define        (kPlayerFlatClumps,            2)
  194. #define        (kPlayerTreePercentage,            0.1)
  195.  
  196.  
  197. //////////////////////////////////////////////////////////////////////
  198. // inner neutral definitions
  199. #define        (kNeutralInnerRadius,            0.34)
  200. #define        (kNeutralOuterRadius,            0.55)
  201. #define        (kNeutralOptimalFactor,            0.7)
  202. #define        (kNumInnerNeutrals,            Between(4, 4))
  203. #define        (kInnerNeutralPercentLand,        0.3)
  204. #define        (kInnerNeutralPercentFlat,        0.9)
  205. #define        (kInnerNeutralTreePercentage,          0.1)
  206. #define        (kInnerNeutralLandChaos,        0.9)
  207. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  208. #define        (kInnerNeutralFlatChaos,        0.8)
  209. #define        (kInnerNeutralFlatClumps,        1)
  210.  
  211.  
  212. //////////////////////////////////////////////////////////////////////
  213. // outer neutral definitions
  214. #define        (kNumOuterNeutrals,            15)
  215. #define        (kOuterNeutralPercentLand,        0.5)
  216. #define        (kOuterNeutralPercentFlat,        0.8)
  217. #define        (kOuterNeutralTreePercentage,          0.1)
  218. #define        (kOuterNeutralLandChaos,        0.8)
  219. #define        (kOuterNeutralLandClumps,        2)
  220. #define        (kOuterNeutralFlatChaos,        0.8)
  221. #define        (kOuterNeutralFlatClumps,        1)
  222.  
  223.  
  224. //////////////////////////////////////////////////////////////////////
  225. // resource definitions
  226. #define        (kMaxResourceElevation,            2)
  227. #define        (kResourceToEdgeDistance,        1)
  228. #define        (kResourceToWaterDistance,        1)
  229.  
  230. #define        (kAnimalPerPlayer,            0)
  231. #define        (kAnimalPerNeutral,            0)
  232.  
  233. #if (IsPaleoEpoch) 
  234.   #define  (kBerryPerPlayer,    2)
  235. #else
  236.   #define  (kBerryPerPlayer,    1)
  237. #endif
  238.  
  239. #define        (kBerryPerNeutral,                0)
  240.  
  241. #define        (kFishPerPlayer,                5)
  242. #define        (kFishPerNeutral,                24)
  243.  
  244. #define        (kGoldPerPlayer,                1)
  245. #define        (kGoldPerNeutral,                2)
  246.  
  247. #define        (kOilPerPlayer,                    0)
  248. #define        (kOilPerNeutral,                0)
  249.  
  250. #define        (kSteelPerPlayer,                1)
  251. #define        (kSteelPerNeutral,                2)
  252.  
  253. #define        (kStonePerPlayer,                1)
  254. #define        (kStonePerNeutral,                2)
  255.  
  256. #define        (kTreePerPlayer,                0)
  257. #define        (kTreePerNeutral,                0)
  258.  
  259.  
  260. //////////////////////////////////////////////////////////////////////
  261. // forest definitions
  262. #define        (kForestFreeRadius,            7.0)
  263. #define        (kForestsPerPlayer,            1)
  264. #define        (kForestChaosLevel,            0.1)
  265. #define        (kMaxClumpsPerForest,              2)
  266.  
  267. #elif Is4Players
  268. //////////////////////////////////////////////////////////////////////
  269. // 4 PLAYERS...
  270. //////////////////////////////////////////////////////////////////////
  271.  
  272. PlaceResourceInRing (Gold, 12, 14)
  273. PlaceResourceInRing (Iron, 12, 14)
  274.  
  275. //////////////////////////////////////////////////////////////////////
  276. // terrain definitions
  277. HeightMapSmoothness                    0)
  278. #define        (kMinIntElevation,            -10)
  279. #define        (kMaxIntElevation,            10)
  280. #define        (kElevationScale,                0.7)
  281. #define        (kPercentLand,                Between(.74, .74))
  282. #define        (kWaterBorder,                6)
  283. #define        (kHeightMapChaos,                Between(8, 15))
  284.                                             
  285. #define        (kMinimumStartPositionToMapEdge        1)
  286. #define        (kOuterPushFromMapCenter        24)
  287. #define        (kInnerPushFromMapCenter         0)
  288.  
  289. //////////////////////////////////////////////////////////////////////
  290. // player definitions
  291. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  292. #define        (kPlayerInnerRadius,            0.8)
  293. #define        (kPlayerOuterRadius,            0.99)
  294. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  295. #define        (kPlayerPercentFlat,            Between(0.94, 0.94))
  296. #define        (kPlayerLandChaos,            0.8)
  297. #define        (kPlayerLandClumps,            1)
  298. #define        (kPlayerFlatChaos,            0.8)
  299. #define        (kPlayerFlatClumps,            2)
  300. #define        (kPlayerTreePercentage,            0.1)
  301.  
  302.  
  303. //////////////////////////////////////////////////////////////////////
  304. // inner neutral definitions
  305. #define        (kNeutralInnerRadius,            0.34)
  306. #define        (kNeutralOuterRadius,            0.55)
  307. #define        (kNeutralOptimalFactor,            0.7)
  308. #define        (kNumInnerNeutrals,            Between(4, 4))
  309. #define        (kInnerNeutralPercentLand,        0.3)
  310. #define        (kInnerNeutralPercentFlat,        0.9)
  311. #define        (kInnerNeutralTreePercentage,          0.1)
  312. #define        (kInnerNeutralLandChaos,        0.9)
  313. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  314. #define        (kInnerNeutralFlatChaos,        0.8)
  315. #define        (kInnerNeutralFlatClumps,        1)
  316.  
  317.  
  318. //////////////////////////////////////////////////////////////////////
  319. // outer neutral definitions
  320. #define        (kNumOuterNeutrals,            15)
  321. #define        (kOuterNeutralPercentLand,        0.5)
  322. #define        (kOuterNeutralPercentFlat,        0.8)
  323. #define        (kOuterNeutralTreePercentage,          0.1)
  324. #define        (kOuterNeutralLandChaos,        0.8)
  325. #define        (kOuterNeutralLandClumps,        2)
  326. #define        (kOuterNeutralFlatChaos,        0.8)
  327. #define        (kOuterNeutralFlatClumps,        1)
  328.  
  329.  
  330. //////////////////////////////////////////////////////////////////////
  331. // resource definitions
  332. #define        (kMaxResourceElevation,            2)
  333. #define        (kResourceToEdgeDistance,        1)
  334. #define        (kResourceToWaterDistance,        1)
  335.  
  336. #define        (kAnimalPerPlayer,            0)
  337. #define        (kAnimalPerNeutral,            0)
  338.  
  339. #if (IsPaleoEpoch) 
  340.   #define  (kBerryPerPlayer,    2)
  341. #else
  342.   #define  (kBerryPerPlayer,    1)
  343. #endif
  344.  
  345. #define        (kBerryPerNeutral,                0)
  346.  
  347. #define        (kFishPerPlayer,                5)
  348. #define        (kFishPerNeutral,                24)
  349.  
  350. #define        (kGoldPerPlayer,                1)
  351. #define        (kGoldPerNeutral,                2)
  352.  
  353. #define        (kOilPerPlayer,                    0)
  354. #define        (kOilPerNeutral,                0)
  355.  
  356. #define        (kSteelPerPlayer,                1)
  357. #define        (kSteelPerNeutral,                2)
  358.  
  359. #define        (kStonePerPlayer,                1)
  360. #define        (kStonePerNeutral,                2)
  361.  
  362. #define        (kTreePerPlayer,                0)
  363. #define        (kTreePerNeutral,                2)
  364.  
  365.  
  366. //////////////////////////////////////////////////////////////////////
  367. // forest definitions
  368. #define        (kForestFreeRadius,            7.0)
  369. #define        (kForestsPerPlayer,            1)
  370. #define        (kForestChaosLevel,            0.1)
  371. #define        (kMaxClumpsPerForest,              2)
  372.  
  373. #elif Is5Players
  374. //////////////////////////////////////////////////////////////////////
  375. // 5 PLAYERS...
  376. //////////////////////////////////////////////////////////////////////
  377.  
  378. PlaceResourceInRing (Gold, 10, 12)
  379. PlaceResourceInRing (Iron, 10, 12)
  380.  
  381. //////////////////////////////////////////////////////////////////////
  382. // terrain definitions
  383. HeightMapSmoothness                    0)
  384. #define        (kMinIntElevation,            -10)
  385. #define        (kMaxIntElevation,            10)
  386. #define        (kElevationScale,                0.7)
  387. #define        (kPercentLand,                Between(.74, .74))
  388. #define        (kWaterBorder,                6)
  389. #define        (kHeightMapChaos,                Between(8, 15))
  390.                                             
  391. #define        (kMinimumStartPositionToMapEdge        1)
  392. #define        (kOuterPushFromMapCenter        24)
  393. #define        (kInnerPushFromMapCenter         0)
  394.  
  395. //////////////////////////////////////////////////////////////////////
  396. // player definitions
  397. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  398. #define        (kPlayerInnerRadius,            0.8)
  399. #define        (kPlayerOuterRadius,            0.99)
  400. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  401. #define        (kPlayerPercentFlat,            Between(0.94, 0.94))
  402. #define        (kPlayerLandChaos,            0.8)
  403. #define        (kPlayerLandClumps,            1)
  404. #define        (kPlayerFlatChaos,            0.8)
  405. #define        (kPlayerFlatClumps,            2)
  406. #define        (kPlayerTreePercentage,            0.1)
  407.  
  408.  
  409. //////////////////////////////////////////////////////////////////////
  410. // inner neutral definitions
  411. #define        (kNeutralInnerRadius,            0.34)
  412. #define        (kNeutralOuterRadius,            0.55)
  413. #define        (kNeutralOptimalFactor,            0.7)
  414. #define        (kNumInnerNeutrals,            Between(4, 4))
  415. #define        (kInnerNeutralPercentLand,        0.3)
  416. #define        (kInnerNeutralPercentFlat,        0.9)
  417. #define        (kInnerNeutralTreePercentage,          0.1)
  418. #define        (kInnerNeutralLandChaos,        0.9)
  419. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  420. #define        (kInnerNeutralFlatChaos,        0.8)
  421. #define        (kInnerNeutralFlatClumps,        1)
  422.  
  423.  
  424. //////////////////////////////////////////////////////////////////////
  425. // outer neutral definitions
  426. #define        (kNumOuterNeutrals,            15)
  427. #define        (kOuterNeutralPercentLand,        0.5)
  428. #define        (kOuterNeutralPercentFlat,        0.8)
  429. #define        (kOuterNeutralTreePercentage,          0.1)
  430. #define        (kOuterNeutralLandChaos,        0.8)
  431. #define        (kOuterNeutralLandClumps,        2)
  432. #define        (kOuterNeutralFlatChaos,        0.8)
  433. #define        (kOuterNeutralFlatClumps,        1)
  434.  
  435.  
  436. //////////////////////////////////////////////////////////////////////
  437. // resource definitions
  438. #define        (kMaxResourceElevation,            2)
  439. #define        (kResourceToEdgeDistance,        1)
  440. #define        (kResourceToWaterDistance,        1)
  441.  
  442. #define        (kAnimalPerPlayer,            0)
  443. #define        (kAnimalPerNeutral,            0)
  444.  
  445. #if (IsPaleoEpoch) 
  446.   #define  (kBerryPerPlayer,    2)
  447. #else
  448.   #define  (kBerryPerPlayer,    1)
  449. #endif
  450.  
  451. #define        (kBerryPerNeutral,                0)
  452.  
  453. #define        (kFishPerPlayer,                5)
  454. #define        (kFishPerNeutral,                24)
  455.  
  456. #define        (kGoldPerPlayer,                1)
  457. #define        (kGoldPerNeutral,                2)
  458.  
  459. #define        (kOilPerPlayer,                    0)
  460. #define        (kOilPerNeutral,                0)
  461.  
  462. #define        (kSteelPerPlayer,                1)
  463. #define        (kSteelPerNeutral,                2)
  464.  
  465. #define        (kStonePerPlayer,                1)
  466. #define        (kStonePerNeutral,                2)
  467.  
  468. #define        (kTreePerPlayer,                0)
  469. #define        (kTreePerNeutral,                0)
  470.  
  471.  
  472. //////////////////////////////////////////////////////////////////////
  473. // forest definitions
  474. #define        (kForestFreeRadius,            7.0)
  475. #define        (kForestsPerPlayer,            1)
  476. #define        (kForestChaosLevel,            0.1)
  477. #define        (kMaxClumpsPerForest,              2)
  478.  
  479. #elif Is6Players
  480. //////////////////////////////////////////////////////////////////////
  481. // 6 PLAYERS...
  482. //////////////////////////////////////////////////////////////////////
  483.  
  484. //////////////////////////////////////////////////////////////////////
  485. // terrain definitions
  486. HeightMapSmoothness                    0)
  487. #define        (kMinIntElevation,            -10)
  488. #define        (kMaxIntElevation,            10)
  489. #define        (kElevationScale,                0.7)
  490. #define        (kPercentLand,                Between(.75, .75))
  491. #define        (kWaterBorder,                6)
  492. #define        (kHeightMapChaos,                Between(8, 15))
  493.                                             
  494. #define        (kMinimumStartPositionToMapEdge        1)
  495. #define        (kOuterPushFromMapCenter        24)
  496. #define        (kInnerPushFromMapCenter         0)
  497.  
  498. //////////////////////////////////////////////////////////////////////
  499. // player definitions
  500. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  501. #define        (kPlayerInnerRadius,            0.8)
  502. #define        (kPlayerOuterRadius,            0.99)
  503. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  504. #define        (kPlayerPercentFlat,            Between(0.94, 0.94))
  505. #define        (kPlayerLandChaos,            0.8)
  506. #define        (kPlayerLandClumps,            1)
  507. #define        (kPlayerFlatChaos,            0.8)
  508. #define        (kPlayerFlatClumps,            2)
  509. #define        (kPlayerTreePercentage,            0.1)
  510.  
  511.  
  512. //////////////////////////////////////////////////////////////////////
  513. // inner neutral definitions
  514. #define        (kNeutralInnerRadius,            0.34)
  515. #define        (kNeutralOuterRadius,            0.55)
  516. #define        (kNeutralOptimalFactor,            0.7)
  517. #define        (kNumInnerNeutrals,            Between(4, 4))
  518. #define        (kInnerNeutralPercentLand,        0.3)
  519. #define        (kInnerNeutralPercentFlat,        0.9)
  520. #define        (kInnerNeutralTreePercentage,          0.1)
  521. #define        (kInnerNeutralLandChaos,        0.9)
  522. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  523. #define        (kInnerNeutralFlatChaos,        0.8)
  524. #define        (kInnerNeutralFlatClumps,        1)
  525.  
  526.  
  527. //////////////////////////////////////////////////////////////////////
  528. // outer neutral definitions
  529. #define        (kNumOuterNeutrals,            15)
  530. #define        (kOuterNeutralPercentLand,        0.5)
  531. #define        (kOuterNeutralPercentFlat,        0.8)
  532. #define        (kOuterNeutralTreePercentage,          0.1)
  533. #define        (kOuterNeutralLandChaos,        0.8)
  534. #define        (kOuterNeutralLandClumps,        2)
  535. #define        (kOuterNeutralFlatChaos,        0.8)
  536. #define        (kOuterNeutralFlatClumps,        1)
  537.  
  538.  
  539. //////////////////////////////////////////////////////////////////////
  540. // resource definitions
  541. #define        (kMaxResourceElevation,            2)
  542. #define        (kResourceToEdgeDistance,        1)
  543. #define        (kResourceToWaterDistance,        1)
  544.  
  545. #define        (kAnimalPerPlayer,            0)
  546. #define        (kAnimalPerNeutral,            0)
  547.  
  548. #if (IsPaleoEpoch) 
  549.   #define  (kBerryPerPlayer,    2)
  550. #else
  551.   #define  (kBerryPerPlayer,    1)
  552. #endif
  553.  
  554. #define        (kBerryPerNeutral,                0)
  555.  
  556. #define        (kFishPerPlayer,                5)
  557. #define        (kFishPerNeutral,                24)
  558.  
  559. #define        (kGoldPerPlayer,                1)
  560. #define        (kGoldPerNeutral,                4)
  561.  
  562. #define        (kOilPerPlayer,                    0)
  563. #define        (kOilPerNeutral,                0)
  564.  
  565. #define        (kSteelPerPlayer,                1)
  566. #define        (kSteelPerNeutral,                4)
  567.  
  568. #define        (kStonePerPlayer,                1)
  569. #define        (kStonePerNeutral,                2)
  570.  
  571. #define        (kTreePerPlayer,                0)
  572. #define        (kTreePerNeutral,                0)
  573.  
  574.  
  575. //////////////////////////////////////////////////////////////////////
  576. // forest definitions
  577. #define        (kForestFreeRadius,            7.0)
  578. #define        (kForestsPerPlayer,            1)
  579. #define        (kForestChaosLevel,            0.1)
  580. #define        (kMaxClumpsPerForest,              2)
  581.  
  582.  
  583. #elif Is7Players
  584. //////////////////////////////////////////////////////////////////////
  585. // 7 PLAYERS...
  586. //////////////////////////////////////////////////////////////////////
  587.  
  588. //////////////////////////////////////////////////////////////////////
  589. // terrain definitions
  590. HeightMapSmoothness                    0)
  591. #define        (kMinIntElevation,            -10)
  592. #define        (kMaxIntElevation,            10)
  593. #define        (kElevationScale,                0.7)
  594. #define        (kPercentLand,                Between(.76, .76))
  595. #define        (kWaterBorder,                6)
  596. #define        (kHeightMapChaos,                Between(8, 15))
  597.                                             
  598. #define        (kMinimumStartPositionToMapEdge        1)
  599. #define        (kOuterPushFromMapCenter        24)
  600. #define        (kInnerPushFromMapCenter         0)
  601.  
  602. //////////////////////////////////////////////////////////////////////
  603. // player definitions
  604. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  605. #define        (kPlayerInnerRadius,            0.8)
  606. #define        (kPlayerOuterRadius,            0.99)
  607. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  608. #define        (kPlayerPercentFlat,            Between(0.94, 0.94))
  609. #define        (kPlayerLandChaos,            0.8)
  610. #define        (kPlayerLandClumps,            1)
  611. #define        (kPlayerFlatChaos,            0.8)
  612. #define        (kPlayerFlatClumps,            2)
  613. #define        (kPlayerTreePercentage,            0.1)
  614.  
  615.  
  616. //////////////////////////////////////////////////////////////////////
  617. // inner neutral definitions
  618. #define        (kNeutralInnerRadius,            0.34)
  619. #define        (kNeutralOuterRadius,            0.55)
  620. #define        (kNeutralOptimalFactor,            0.7)
  621. #define        (kNumInnerNeutrals,            Between(4, 4))
  622. #define        (kInnerNeutralPercentLand,        0.3)
  623. #define        (kInnerNeutralPercentFlat,        0.9)
  624. #define        (kInnerNeutralTreePercentage,          0.1)
  625. #define        (kInnerNeutralLandChaos,        0.9)
  626. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  627. #define        (kInnerNeutralFlatChaos,        0.8)
  628. #define        (kInnerNeutralFlatClumps,        1)
  629.  
  630.  
  631. //////////////////////////////////////////////////////////////////////
  632. // outer neutral definitions
  633. #define        (kNumOuterNeutrals,            15)
  634. #define        (kOuterNeutralPercentLand,        0.5)
  635. #define        (kOuterNeutralPercentFlat,        0.8)
  636. #define        (kOuterNeutralTreePercentage,          0.1)
  637. #define        (kOuterNeutralLandChaos,        0.8)
  638. #define        (kOuterNeutralLandClumps,        2)
  639. #define        (kOuterNeutralFlatChaos,        0.8)
  640. #define        (kOuterNeutralFlatClumps,        1)
  641.  
  642.  
  643. //////////////////////////////////////////////////////////////////////
  644. // resource definitions
  645. #define        (kMaxResourceElevation,            2)
  646. #define        (kResourceToEdgeDistance,        1)
  647. #define        (kResourceToWaterDistance,        1)
  648.  
  649. #define        (kAnimalPerPlayer,            0)
  650. #define        (kAnimalPerNeutral,            0)
  651.  
  652. #if (IsPaleoEpoch) 
  653.   #define  (kBerryPerPlayer,    2)
  654. #else
  655.   #define  (kBerryPerPlayer,    1)
  656. #endif
  657.  
  658. #define        (kBerryPerNeutral,                0)
  659.  
  660. #define        (kFishPerPlayer,                5)
  661. #define        (kFishPerNeutral,                24)
  662.  
  663. #define        (kGoldPerPlayer,                1)
  664. #define        (kGoldPerNeutral,                4)
  665.  
  666. #define        (kOilPerPlayer,                    0)
  667. #define        (kOilPerNeutral,                0)
  668.  
  669. #define        (kSteelPerPlayer,                1)
  670. #define        (kSteelPerNeutral,                4)
  671.  
  672. #define        (kStonePerPlayer,                1)
  673. #define        (kStonePerNeutral,                2)
  674.  
  675. #define        (kTreePerPlayer,                0)
  676. #define        (kTreePerNeutral,                0)
  677.  
  678.  
  679. //////////////////////////////////////////////////////////////////////
  680. // forest definitions
  681. #define        (kForestFreeRadius,            7.0)
  682. #define        (kForestsPerPlayer,            1)
  683. #define        (kForestChaosLevel,            0.1)
  684. #define        (kMaxClumpsPerForest,              2)
  685.  
  686. #elif Is8Players
  687. //////////////////////////////////////////////////////////////////////
  688. // 8 PLAYERS...
  689. //////////////////////////////////////////////////////////////////////
  690.  
  691. //////////////////////////////////////////////////////////////////////
  692. // terrain definitions
  693. HeightMapSmoothness                    0)
  694. #define        (kMinIntElevation,            -10)
  695. #define        (kMaxIntElevation,            10)
  696. #define        (kElevationScale,                0.7)
  697. #define        (kPercentLand,                Between(.76, .76))
  698. #define        (kWaterBorder,                6)
  699. #define        (kHeightMapChaos,                Between(8, 15))
  700.                                             
  701. #define        (kMinimumStartPositionToMapEdge        1)
  702. #define        (kOuterPushFromMapCenter        24)
  703. #define        (kInnerPushFromMapCenter         0)
  704.  
  705. //////////////////////////////////////////////////////////////////////
  706. // player definitions
  707. #define        (kMaxAngleBetweenTeamMembers,        75.0)
  708. #define        (kPlayerInnerRadius,            0.8)
  709. #define        (kPlayerOuterRadius,            0.99)
  710. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  711. #define        (kPlayerPercentFlat,            Between(0.94, 0.94))
  712. #define        (kPlayerLandChaos,            0.8)
  713. #define        (kPlayerLandClumps,            1)
  714. #define        (kPlayerFlatChaos,            0.8)
  715. #define        (kPlayerFlatClumps,            2)
  716. #define        (kPlayerTreePercentage,            0.1)
  717.  
  718.  
  719. //////////////////////////////////////////////////////////////////////
  720. // inner neutral definitions
  721. #define        (kNeutralInnerRadius,            0.34)
  722. #define        (kNeutralOuterRadius,            0.55)
  723. #define        (kNeutralOptimalFactor,            0.7)
  724. #define        (kNumInnerNeutrals,            Between(4, 4))
  725. #define        (kInnerNeutralPercentLand,        0.3)
  726. #define        (kInnerNeutralPercentFlat,        0.9)
  727. #define        (kInnerNeutralTreePercentage,          0.1)
  728. #define        (kInnerNeutralLandChaos,        0.9)
  729. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  730. #define        (kInnerNeutralFlatChaos,        0.8)
  731. #define        (kInnerNeutralFlatClumps,        1)
  732.  
  733.  
  734. //////////////////////////////////////////////////////////////////////
  735. // outer neutral definitions
  736. #define        (kNumOuterNeutrals,            15)
  737. #define        (kOuterNeutralPercentLand,        0.5)
  738. #define        (kOuterNeutralPercentFlat,        0.8)
  739. #define        (kOuterNeutralTreePercentage,          0.1)
  740. #define        (kOuterNeutralLandChaos,        0.8)
  741. #define        (kOuterNeutralLandClumps,        2)
  742. #define        (kOuterNeutralFlatChaos,        0.8)
  743. #define        (kOuterNeutralFlatClumps,        1)
  744.  
  745.  
  746. //////////////////////////////////////////////////////////////////////
  747. // resource definitions
  748. #define        (kMaxResourceElevation,            2)
  749. #define        (kResourceToEdgeDistance,        1)
  750. #define        (kResourceToWaterDistance,        1)
  751.  
  752. #define        (kAnimalPerPlayer,            0)
  753. #define        (kAnimalPerNeutral,            0)
  754.  
  755. #if (IsPaleoEpoch) 
  756.   #define  (kBerryPerPlayer,    2)
  757. #else
  758.   #define  (kBerryPerPlayer,    1)
  759. #endif
  760.  
  761. #define        (kBerryPerNeutral,                0)
  762.  
  763. #define        (kFishPerPlayer,                5)
  764. #define        (kFishPerNeutral,                24)
  765.  
  766. #define        (kGoldPerPlayer,                1)
  767. #define        (kGoldPerNeutral,                4)
  768.  
  769. #define        (kOilPerPlayer,                    0)
  770. #define        (kOilPerNeutral,                0)
  771.  
  772. #define        (kSteelPerPlayer,                1)
  773. #define        (kSteelPerNeutral,                4)
  774.  
  775. #define        (kStonePerPlayer,                1)
  776. #define        (kStonePerNeutral,                2)
  777.  
  778. #define        (kTreePerPlayer,                0)
  779. #define        (kTreePerNeutral,                0)
  780.  
  781.  
  782. //////////////////////////////////////////////////////////////////////
  783. // forest definitions
  784. #define        (kForestFreeRadius,            7.0)
  785. #define        (kForestsPerPlayer,            1)
  786. #define        (kForestChaosLevel,            0.1)
  787. #define        (kMaxClumpsPerForest,              2)
  788.  
  789.  
  790. #elif Is9Players
  791. //////////////////////////////////////////////////////////////////////
  792. // 9 PLAYERS...
  793. //////////////////////////////////////////////////////////////////////
  794.  
  795. //////////////////////////////////////////////////////////////////////
  796. // terrain definitions
  797. #define        (kMinIntElevation,            -10)
  798. #define        (kMaxIntElevation,            10)
  799. #define        (kElevationScale,                0.99)
  800. #define        (kPercentLand,                Between(.88, .88))
  801. #define        (kWaterBorder,                0)
  802. #define        (kHeightMapChaos,                Between(8, 15))
  803.  
  804. #define        (kMinimumStartPositionToMapEdge    1)
  805. #define        (kOuterPushFromMapCenter        10)
  806. #define        (kInnerPushFromMapCenter         0)                                            
  807. //////////////////////////////////////////////////////////////////////
  808. // player definitions
  809. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  810. #define        (kPlayerInnerRadius,            0.9)
  811. #define        (kPlayerOuterRadius,            0.999)
  812. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  813. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  814. #define        (kPlayerLandChaos,            0.8)
  815. #define        (kPlayerLandClumps,            1)
  816. #define        (kPlayerFlatChaos,            0.8)
  817. #define        (kPlayerFlatClumps,            2)
  818. #define        (kPlayerTreePercentage,            0.1)
  819.  
  820.  
  821. //////////////////////////////////////////////////////////////////////
  822. // inner neutral definitions
  823. #define        (kNeutralInnerRadius,            0.45)
  824. #define        (kNeutralOuterRadius,            0.45)
  825. #define        (kNeutralOptimalFactor,            0.7)
  826. #define        (kNumInnerNeutrals,            Between(0, 0))
  827. #define        (kInnerNeutralPercentLand,        0.08)
  828. #define        (kInnerNeutralPercentFlat,        0.9)
  829. #define        (kInnerNeutralTreePercentage,          0.2)
  830. #define        (kInnerNeutralLandChaos,        0.9)
  831. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  832. #define        (kInnerNeutralFlatChaos,        0.8)
  833. #define        (kInnerNeutralFlatClumps,        1)
  834.  
  835.  
  836. //////////////////////////////////////////////////////////////////////
  837. // outer neutral definitions
  838. #define        (kNumOuterNeutrals,            7)
  839. #define        (kOuterNeutralPercentLand,        0.3)
  840. #define        (kOuterNeutralPercentFlat,        0.9)
  841. #define        (kOuterNeutralTreePercentage,          0.25)
  842. #define        (kOuterNeutralLandChaos,        0.8)
  843. #define        (kOuterNeutralLandClumps,        2)
  844. #define        (kOuterNeutralFlatChaos,        0.8)
  845. #define        (kOuterNeutralFlatClumps,        1)
  846.  
  847.  
  848. //////////////////////////////////////////////////////////////////////
  849. // resource definitions
  850. #define        (kMaxResourceElevation,            3)
  851. #define        (kResourceToEdgeDistance,        1)
  852. #define        (kResourceToWaterDistance,        1)
  853.  
  854. #define        (kAnimalPerPlayer,            0)
  855. #define        (kAnimalPerNeutral,            0)
  856.  
  857. #define        (kBerryPerPlayer,                1)
  858. #define        (kBerryPerNeutral,            0)
  859.  
  860. #define        (kFishPerPlayer,                0)
  861. #define        (kFishPerNeutral,                24)
  862.  
  863. #define        (kGoldPerPlayer,                1)
  864. #define        (kGoldPerNeutral,                5)
  865.  
  866. #define        (kOilPerPlayer,                0)
  867. #define        (kOilPerNeutral,                0)
  868.  
  869. #define        (kSteelPerPlayer,                1)
  870. #define        (kSteelPerNeutral,            5)
  871.  
  872. #define        (kStonePerPlayer,                1)
  873. #define        (kStonePerNeutral,            2)
  874.  
  875. #define        (kTreePerPlayer,                0)
  876. #define        (kTreePerNeutral,                0)
  877.  
  878.  
  879. //////////////////////////////////////////////////////////////////////
  880. // forest definitions
  881. #define        (kForestFreeRadius,            4.0)
  882. #define        (kForestsPerPlayer,            1)
  883. #define        (kForestChaosLevel,            0.1)
  884. #define        (kMaxClumpsPerForest,              2)
  885.  
  886.  
  887. #elif Is10Players
  888. //////////////////////////////////////////////////////////////////////
  889. // 10 PLAYERS...
  890. //////////////////////////////////////////////////////////////////////
  891.  
  892. //////////////////////////////////////////////////////////////////////
  893. // terrain definitions
  894. #define        (kMinIntElevation,            -10)
  895. #define        (kMaxIntElevation,            10)
  896. #define        (kElevationScale,                0.99)
  897. #define        (kPercentLand,                Between(.88, .88))
  898. #define        (kWaterBorder,                0)
  899. #define        (kHeightMapChaos,                Between(8, 15))
  900.  
  901. #define        (kMinimumStartPositionToMapEdge    1)
  902. #define        (kOuterPushFromMapCenter        10)
  903. #define        (kInnerPushFromMapCenter         0)                                            
  904. //////////////////////////////////////////////////////////////////////
  905. // player definitions
  906. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  907. #define        (kPlayerInnerRadius,            0.9)
  908. #define        (kPlayerOuterRadius,            0.999)
  909. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  910. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  911. #define        (kPlayerLandChaos,            0.8)
  912. #define        (kPlayerLandClumps,            1)
  913. #define        (kPlayerFlatChaos,            0.8)
  914. #define        (kPlayerFlatClumps,            2)
  915. #define        (kPlayerTreePercentage,            0.1)
  916.  
  917.  
  918. //////////////////////////////////////////////////////////////////////
  919. // inner neutral definitions
  920. #define        (kNeutralInnerRadius,            0.45)
  921. #define        (kNeutralOuterRadius,            0.45)
  922. #define        (kNeutralOptimalFactor,            0.7)
  923. #define        (kNumInnerNeutrals,            Between(0, 0))
  924. #define        (kInnerNeutralPercentLand,        0.08)
  925. #define        (kInnerNeutralPercentFlat,        0.9)
  926. #define        (kInnerNeutralTreePercentage,          0.2)
  927. #define        (kInnerNeutralLandChaos,        0.9)
  928. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  929. #define        (kInnerNeutralFlatChaos,        0.8)
  930. #define        (kInnerNeutralFlatClumps,        1)
  931.  
  932.  
  933. //////////////////////////////////////////////////////////////////////
  934. // outer neutral definitions
  935. #define        (kNumOuterNeutrals,            7)
  936. #define        (kOuterNeutralPercentLand,        0.3)
  937. #define        (kOuterNeutralPercentFlat,        0.9)
  938. #define        (kOuterNeutralTreePercentage,          0.25)
  939. #define        (kOuterNeutralLandChaos,        0.8)
  940. #define        (kOuterNeutralLandClumps,        2)
  941. #define        (kOuterNeutralFlatChaos,        0.8)
  942. #define        (kOuterNeutralFlatClumps,        1)
  943.  
  944.  
  945. //////////////////////////////////////////////////////////////////////
  946. // resource definitions
  947. #define        (kMaxResourceElevation,            3)
  948. #define        (kResourceToEdgeDistance,        1)
  949. #define        (kResourceToWaterDistance,        1)
  950.  
  951. #define        (kAnimalPerPlayer,            0)
  952. #define        (kAnimalPerNeutral,            0)
  953.  
  954. #define        (kBerryPerPlayer,                1)
  955. #define        (kBerryPerNeutral,            0)
  956.  
  957. #define        (kFishPerPlayer,                0)
  958. #define        (kFishPerNeutral,                24)
  959.  
  960. #define        (kGoldPerPlayer,                1)
  961. #define        (kGoldPerNeutral,                5)
  962.  
  963. #define        (kOilPerPlayer,                0)
  964. #define        (kOilPerNeutral,                0)
  965.  
  966. #define        (kSteelPerPlayer,                1)
  967. #define        (kSteelPerNeutral,            5)
  968.  
  969. #define        (kStonePerPlayer,                1)
  970. #define        (kStonePerNeutral,            2)
  971.  
  972. #define        (kTreePerPlayer,                0)
  973. #define        (kTreePerNeutral,                0)
  974.  
  975.  
  976. //////////////////////////////////////////////////////////////////////
  977. // forest definitions
  978. #define        (kForestFreeRadius,            4.0)
  979. #define        (kForestsPerPlayer,            1)
  980. #define        (kForestChaosLevel,            0.1)
  981. #define        (kMaxClumpsPerForest,              2)
  982.  
  983.  
  984. #elif Is11Players
  985. //////////////////////////////////////////////////////////////////////
  986. // 11 PLAYERS...
  987. //////////////////////////////////////////////////////////////////////
  988.  
  989. //////////////////////////////////////////////////////////////////////
  990. // terrain definitions
  991. #define        (kMinIntElevation,                -10)
  992. #define        (kMaxIntElevation,                20)
  993. #define        (kElevationScale,                0.6)
  994. #define        (kPercentLand,                    Between(0.5, 0.75))
  995. #define        (kWaterBorder,                    10)
  996. #define        (kHeightMapChaos,                5.0)
  997.                                             
  998.  
  999. //////////////////////////////////////////////////////////////////////
  1000. // player definitions
  1001. #define        (kMaxAngleBetweenTeamMembers,    90.0)
  1002. #define        (kPlayerInnerRadius,            0.4)
  1003. #define        (kPlayerOuterRadius,            0.75)
  1004. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1005. #define        (kPlayerPercentFlat,            Between(0.5, 0.75))
  1006. #define        (kPlayerLandChaos,                0.8)
  1007. #define        (kPlayerLandClumps,                2)
  1008. #define        (kPlayerFlatChaos,                0.8)
  1009. #define        (kPlayerFlatClumps,                2)
  1010. #define        (kPlayerTreePercentage,            0.04)
  1011.  
  1012.  
  1013. //////////////////////////////////////////////////////////////////////
  1014. // inner neutral definitions
  1015. #define        (kNeutralInnerRadius,            0.05)
  1016. #define        (kNeutralOuterRadius,            0.4)
  1017. #define        (kNeutralOptimalFactor,            0.7)
  1018. #define        (kNumInnerNeutrals,                1)
  1019. #define        (kInnerNeutralPercentLand,        0.35)
  1020. #define        (kInnerNeutralPercentFlat,        0.5)
  1021. #define        (kInnerNeutralTreePercentage,    0.04)
  1022. #define        (kInnerNeutralLandChaos,        0.8)
  1023. #define        (kInnerNeutralLandClumps,        1)
  1024. #define        (kInnerNeutralFlatChaos,        0.8)
  1025. #define        (kInnerNeutralFlatClumps,        1)
  1026.  
  1027.  
  1028. //////////////////////////////////////////////////////////////////////
  1029. // outer neutral definitions
  1030. #define        (kNumOuterNeutrals,                1)
  1031. #define        (kOuterNeutralPercentLand,        0.35)
  1032. #define        (kOuterNeutralPercentFlat,        0.5)
  1033. #define        (kOuterNeutralTreePercentage,    0.04)
  1034. #define        (kOuterNeutralLandChaos,        0.8)
  1035. #define        (kOuterNeutralLandClumps,        1)
  1036. #define        (kOuterNeutralFlatChaos,        0.8)
  1037. #define        (kOuterNeutralFlatClumps,        1)
  1038.  
  1039.  
  1040. //////////////////////////////////////////////////////////////////////
  1041. // resource definitions
  1042. #define        (kMaxResourceElevation,            4)
  1043. #define        (kResourceToEdgeDistance,        4)
  1044. #define        (kResourceToWaterDistance,        4)
  1045.  
  1046. #define        (kAnimalPerPlayer,                5)
  1047. #define        (kAnimalPerNeutral,                2)
  1048.  
  1049. #define        (kBerryPerPlayer,                2)
  1050. #define        (kBerryPerNeutral,                2)
  1051.  
  1052. #define        (kFishPerPlayer,                5)
  1053. #define        (kFishPerNeutral,                1)
  1054.  
  1055. #define        (kGoldPerPlayer,                2)
  1056. #define        (kGoldPerNeutral,                2)
  1057.  
  1058. #define        (kOilPerPlayer,                    2)
  1059. #define        (kOilPerNeutral,                2)
  1060.  
  1061. #define        (kSteelPerPlayer,                2)
  1062. #define        (kSteelPerNeutral,                2)
  1063.  
  1064. #define        (kStonePerPlayer,                1)
  1065. #define        (kStonePerNeutral,                2)
  1066.  
  1067. #define        (kTreePerPlayer,                8)
  1068. #define        (kTreePerNeutral,                8)
  1069.  
  1070.  
  1071. //////////////////////////////////////////////////////////////////////
  1072. // forest definitions
  1073. #define        (kForestFreeRadius,                14.0)
  1074. #define        (kForestsPerPlayer,                2)
  1075. #define        (kForestChaosLevel,                0.25)
  1076. #define        (kMaxClumpsPerForest,            15)
  1077.  
  1078.  
  1079. #elif Is12Players
  1080. //////////////////////////////////////////////////////////////////////
  1081. // 12 PLAYERS...
  1082. //////////////////////////////////////////////////////////////////////
  1083.  
  1084. //////////////////////////////////////////////////////////////////////
  1085. // terrain definitions
  1086. #define        (kMinIntElevation,            -10)
  1087. #define        (kMaxIntElevation,            10)
  1088. #define        (kElevationScale,                0.99)
  1089. #define        (kPercentLand,                Between(.88, .88))
  1090. #define        (kWaterBorder,                0)
  1091. #define        (kHeightMapChaos,                Between(8, 15))
  1092.  
  1093. #define        (kMinimumStartPositionToMapEdge    1)
  1094. #define        (kOuterPushFromMapCenter        10)
  1095. #define        (kInnerPushFromMapCenter         0)                                            
  1096. //////////////////////////////////////////////////////////////////////
  1097. // player definitions
  1098. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  1099. #define        (kPlayerInnerRadius,            0.9)
  1100. #define        (kPlayerOuterRadius,            0.999)
  1101. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1102. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  1103. #define        (kPlayerLandChaos,            0.8)
  1104. #define        (kPlayerLandClumps,            1)
  1105. #define        (kPlayerFlatChaos,            0.8)
  1106. #define        (kPlayerFlatClumps,            2)
  1107. #define        (kPlayerTreePercentage,            0.1)
  1108.  
  1109.  
  1110. //////////////////////////////////////////////////////////////////////
  1111. // inner neutral definitions
  1112. #define        (kNeutralInnerRadius,            0.45)
  1113. #define        (kNeutralOuterRadius,            0.45)
  1114. #define        (kNeutralOptimalFactor,            0.7)
  1115. #define        (kNumInnerNeutrals,            Between(0, 0))
  1116. #define        (kInnerNeutralPercentLand,        0.08)
  1117. #define        (kInnerNeutralPercentFlat,        0.9)
  1118. #define        (kInnerNeutralTreePercentage,          0.2)
  1119. #define        (kInnerNeutralLandChaos,        0.9)
  1120. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  1121. #define        (kInnerNeutralFlatChaos,        0.8)
  1122. #define        (kInnerNeutralFlatClumps,        1)
  1123.  
  1124.  
  1125. //////////////////////////////////////////////////////////////////////
  1126. // outer neutral definitions
  1127. #define        (kNumOuterNeutrals,            7)
  1128. #define        (kOuterNeutralPercentLand,        0.3)
  1129. #define        (kOuterNeutralPercentFlat,        0.9)
  1130. #define        (kOuterNeutralTreePercentage,          0.25)
  1131. #define        (kOuterNeutralLandChaos,        0.8)
  1132. #define        (kOuterNeutralLandClumps,        2)
  1133. #define        (kOuterNeutralFlatChaos,        0.8)
  1134. #define        (kOuterNeutralFlatClumps,        1)
  1135.  
  1136.  
  1137. //////////////////////////////////////////////////////////////////////
  1138. // resource definitions
  1139. #define        (kMaxResourceElevation,            3)
  1140. #define        (kResourceToEdgeDistance,        1)
  1141. #define        (kResourceToWaterDistance,        1)
  1142.  
  1143. #define        (kAnimalPerPlayer,            0)
  1144. #define        (kAnimalPerNeutral,            0)
  1145.  
  1146. #define        (kBerryPerPlayer,                1)
  1147. #define        (kBerryPerNeutral,            0)
  1148.  
  1149. #define        (kFishPerPlayer,                0)
  1150. #define        (kFishPerNeutral,                24)
  1151.  
  1152. #define        (kGoldPerPlayer,                1)
  1153. #define        (kGoldPerNeutral,                5)
  1154.  
  1155. #define        (kOilPerPlayer,                0)
  1156. #define        (kOilPerNeutral,                0)
  1157.  
  1158. #define        (kSteelPerPlayer,                1)
  1159. #define        (kSteelPerNeutral,            5)
  1160.  
  1161. #define        (kStonePerPlayer,                1)
  1162. #define        (kStonePerNeutral,            2)
  1163.  
  1164. #define        (kTreePerPlayer,                0)
  1165. #define        (kTreePerNeutral,                0)
  1166.  
  1167.  
  1168. //////////////////////////////////////////////////////////////////////
  1169. // forest definitions
  1170. #define        (kForestFreeRadius,            4.0)
  1171. #define        (kForestsPerPlayer,            1)
  1172. #define        (kForestChaosLevel,            0.1)
  1173. #define        (kMaxClumpsPerForest,              2)
  1174.  
  1175.  
  1176. #elif Is13Players
  1177. //////////////////////////////////////////////////////////////////////
  1178. // 13 PLAYERS...
  1179. //////////////////////////////////////////////////////////////////////
  1180.  
  1181. //////////////////////////////////////////////////////////////////////
  1182. // terrain definitions
  1183. #define        (kMinIntElevation,            -10)
  1184. #define        (kMaxIntElevation,            10)
  1185. #define        (kElevationScale,                0.99)
  1186. #define        (kPercentLand,                Between(.88, .88))
  1187. #define        (kWaterBorder,                0)
  1188. #define        (kHeightMapChaos,                Between(8, 15))
  1189.  
  1190. #define        (kMinimumStartPositionToMapEdge    1)
  1191. #define        (kOuterPushFromMapCenter        10)
  1192. #define        (kInnerPushFromMapCenter         0)                                            
  1193. //////////////////////////////////////////////////////////////////////
  1194. // player definitions
  1195. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  1196. #define        (kPlayerInnerRadius,            0.9)
  1197. #define        (kPlayerOuterRadius,            0.999)
  1198. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1199. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  1200. #define        (kPlayerLandChaos,            0.8)
  1201. #define        (kPlayerLandClumps,            1)
  1202. #define        (kPlayerFlatChaos,            0.8)
  1203. #define        (kPlayerFlatClumps,            2)
  1204. #define        (kPlayerTreePercentage,            0.1)
  1205.  
  1206.  
  1207. //////////////////////////////////////////////////////////////////////
  1208. // inner neutral definitions
  1209. #define        (kNeutralInnerRadius,            0.45)
  1210. #define        (kNeutralOuterRadius,            0.45)
  1211. #define        (kNeutralOptimalFactor,            0.7)
  1212. #define        (kNumInnerNeutrals,            Between(0, 0))
  1213. #define        (kInnerNeutralPercentLand,        0.08)
  1214. #define        (kInnerNeutralPercentFlat,        0.9)
  1215. #define        (kInnerNeutralTreePercentage,          0.2)
  1216. #define        (kInnerNeutralLandChaos,        0.9)
  1217. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  1218. #define        (kInnerNeutralFlatChaos,        0.8)
  1219. #define        (kInnerNeutralFlatClumps,        1)
  1220.  
  1221.  
  1222. //////////////////////////////////////////////////////////////////////
  1223. // outer neutral definitions
  1224. #define        (kNumOuterNeutrals,            7)
  1225. #define        (kOuterNeutralPercentLand,        0.3)
  1226. #define        (kOuterNeutralPercentFlat,        0.9)
  1227. #define        (kOuterNeutralTreePercentage,          0.25)
  1228. #define        (kOuterNeutralLandChaos,        0.8)
  1229. #define        (kOuterNeutralLandClumps,        2)
  1230. #define        (kOuterNeutralFlatChaos,        0.8)
  1231. #define        (kOuterNeutralFlatClumps,        1)
  1232.  
  1233.  
  1234. //////////////////////////////////////////////////////////////////////
  1235. // resource definitions
  1236. #define        (kMaxResourceElevation,            3)
  1237. #define        (kResourceToEdgeDistance,        1)
  1238. #define        (kResourceToWaterDistance,        1)
  1239.  
  1240. #define        (kAnimalPerPlayer,            0)
  1241. #define        (kAnimalPerNeutral,            0)
  1242.  
  1243. #define        (kBerryPerPlayer,                1)
  1244. #define        (kBerryPerNeutral,            0)
  1245.  
  1246. #define        (kFishPerPlayer,                0)
  1247. #define        (kFishPerNeutral,                24)
  1248.  
  1249. #define        (kGoldPerPlayer,                1)
  1250. #define        (kGoldPerNeutral,                5)
  1251.  
  1252. #define        (kOilPerPlayer,                0)
  1253. #define        (kOilPerNeutral,                0)
  1254.  
  1255. #define        (kSteelPerPlayer,                1)
  1256. #define        (kSteelPerNeutral,            5)
  1257.  
  1258. #define        (kStonePerPlayer,                1)
  1259. #define        (kStonePerNeutral,            2)
  1260.  
  1261. #define        (kTreePerPlayer,                0)
  1262. #define        (kTreePerNeutral,                0)
  1263.  
  1264.  
  1265. //////////////////////////////////////////////////////////////////////
  1266. // forest definitions
  1267. #define        (kForestFreeRadius,            4.0)
  1268. #define        (kForestsPerPlayer,            1)
  1269. #define        (kForestChaosLevel,            0.1)
  1270. #define        (kMaxClumpsPerForest,              2)
  1271.  
  1272.  
  1273. #elif Is14Players
  1274. //////////////////////////////////////////////////////////////////////
  1275. // 14 PLAYERS...
  1276. //////////////////////////////////////////////////////////////////////
  1277.  
  1278. //////////////////////////////////////////////////////////////////////
  1279. // terrain definitions
  1280. #define        (kMinIntElevation,            -10)
  1281. #define        (kMaxIntElevation,            10)
  1282. #define        (kElevationScale,                0.99)
  1283. #define        (kPercentLand,                Between(.88, .88))
  1284. #define        (kWaterBorder,                0)
  1285. #define        (kHeightMapChaos,                Between(8, 15))
  1286.  
  1287. #define        (kMinimumStartPositionToMapEdge    1)
  1288. #define        (kOuterPushFromMapCenter        10)
  1289. #define        (kInnerPushFromMapCenter         0)                                            
  1290. //////////////////////////////////////////////////////////////////////
  1291. // player definitions
  1292. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  1293. #define        (kPlayerInnerRadius,            0.9)
  1294. #define        (kPlayerOuterRadius,            0.999)
  1295. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1296. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  1297. #define        (kPlayerLandChaos,            0.8)
  1298. #define        (kPlayerLandClumps,            1)
  1299. #define        (kPlayerFlatChaos,            0.8)
  1300. #define        (kPlayerFlatClumps,            2)
  1301. #define        (kPlayerTreePercentage,            0.1)
  1302.  
  1303.  
  1304. //////////////////////////////////////////////////////////////////////
  1305. // inner neutral definitions
  1306. #define        (kNeutralInnerRadius,            0.45)
  1307. #define        (kNeutralOuterRadius,            0.45)
  1308. #define        (kNeutralOptimalFactor,            0.7)
  1309. #define        (kNumInnerNeutrals,            Between(0, 0))
  1310. #define        (kInnerNeutralPercentLand,        0.08)
  1311. #define        (kInnerNeutralPercentFlat,        0.9)
  1312. #define        (kInnerNeutralTreePercentage,          0.2)
  1313. #define        (kInnerNeutralLandChaos,        0.9)
  1314. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  1315. #define        (kInnerNeutralFlatChaos,        0.8)
  1316. #define        (kInnerNeutralFlatClumps,        1)
  1317.  
  1318.  
  1319. //////////////////////////////////////////////////////////////////////
  1320. // outer neutral definitions
  1321. #define        (kNumOuterNeutrals,            7)
  1322. #define        (kOuterNeutralPercentLand,        0.3)
  1323. #define        (kOuterNeutralPercentFlat,        0.9)
  1324. #define        (kOuterNeutralTreePercentage,          0.25)
  1325. #define        (kOuterNeutralLandChaos,        0.8)
  1326. #define        (kOuterNeutralLandClumps,        2)
  1327. #define        (kOuterNeutralFlatChaos,        0.8)
  1328. #define        (kOuterNeutralFlatClumps,        1)
  1329.  
  1330.  
  1331. //////////////////////////////////////////////////////////////////////
  1332. // resource definitions
  1333. #define        (kMaxResourceElevation,            3)
  1334. #define        (kResourceToEdgeDistance,        1)
  1335. #define        (kResourceToWaterDistance,        1)
  1336.  
  1337. #define        (kAnimalPerPlayer,            0)
  1338. #define        (kAnimalPerNeutral,            0)
  1339.  
  1340. #define        (kBerryPerPlayer,                1)
  1341. #define        (kBerryPerNeutral,            0)
  1342.  
  1343. #define        (kFishPerPlayer,                0)
  1344. #define        (kFishPerNeutral,                24)
  1345.  
  1346. #define        (kGoldPerPlayer,                1)
  1347. #define        (kGoldPerNeutral,                5)
  1348.  
  1349. #define        (kOilPerPlayer,                0)
  1350. #define        (kOilPerNeutral,                0)
  1351.  
  1352. #define        (kSteelPerPlayer,                1)
  1353. #define        (kSteelPerNeutral,            5)
  1354.  
  1355. #define        (kStonePerPlayer,                1)
  1356. #define        (kStonePerNeutral,            2)
  1357.  
  1358. #define        (kTreePerPlayer,                0)
  1359. #define        (kTreePerNeutral,                0)
  1360.  
  1361.  
  1362. //////////////////////////////////////////////////////////////////////
  1363. // forest definitions
  1364. #define        (kForestFreeRadius,            4.0)
  1365. #define        (kForestsPerPlayer,            1)
  1366. #define        (kForestChaosLevel,            0.1)
  1367. #define        (kMaxClumpsPerForest,              2)
  1368.  
  1369.  
  1370. #elif Is15Players
  1371. //////////////////////////////////////////////////////////////////////
  1372. // 15 PLAYERS...
  1373. //////////////////////////////////////////////////////////////////////
  1374.  
  1375. //////////////////////////////////////////////////////////////////////
  1376. // terrain definitions
  1377. #define        (kMinIntElevation,            -10)
  1378. #define        (kMaxIntElevation,            10)
  1379. #define        (kElevationScale,                0.99)
  1380. #define        (kPercentLand,                Between(.88, .88))
  1381. #define        (kWaterBorder,                0)
  1382. #define        (kHeightMapChaos,                Between(8, 15))
  1383.  
  1384. #define        (kMinimumStartPositionToMapEdge    1)
  1385. #define        (kOuterPushFromMapCenter        10)
  1386. #define        (kInnerPushFromMapCenter         0)                                            
  1387. //////////////////////////////////////////////////////////////////////
  1388. // player definitions
  1389. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  1390. #define        (kPlayerInnerRadius,            0.9)
  1391. #define        (kPlayerOuterRadius,            0.999)
  1392. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1393. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  1394. #define        (kPlayerLandChaos,            0.8)
  1395. #define        (kPlayerLandClumps,            1)
  1396. #define        (kPlayerFlatChaos,            0.8)
  1397. #define        (kPlayerFlatClumps,            2)
  1398. #define        (kPlayerTreePercentage,            0.1)
  1399.  
  1400.  
  1401. //////////////////////////////////////////////////////////////////////
  1402. // inner neutral definitions
  1403. #define        (kNeutralInnerRadius,            0.45)
  1404. #define        (kNeutralOuterRadius,            0.45)
  1405. #define        (kNeutralOptimalFactor,            0.7)
  1406. #define        (kNumInnerNeutrals,            Between(0, 0))
  1407. #define        (kInnerNeutralPercentLand,        0.08)
  1408. #define        (kInnerNeutralPercentFlat,        0.9)
  1409. #define        (kInnerNeutralTreePercentage,          0.2)
  1410. #define        (kInnerNeutralLandChaos,        0.9)
  1411. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  1412. #define        (kInnerNeutralFlatChaos,        0.8)
  1413. #define        (kInnerNeutralFlatClumps,        1)
  1414.  
  1415.  
  1416. //////////////////////////////////////////////////////////////////////
  1417. // outer neutral definitions
  1418. #define        (kNumOuterNeutrals,            7)
  1419. #define        (kOuterNeutralPercentLand,        0.3)
  1420. #define        (kOuterNeutralPercentFlat,        0.9)
  1421. #define        (kOuterNeutralTreePercentage,          0.25)
  1422. #define        (kOuterNeutralLandChaos,        0.8)
  1423. #define        (kOuterNeutralLandClumps,        2)
  1424. #define        (kOuterNeutralFlatChaos,        0.8)
  1425. #define        (kOuterNeutralFlatClumps,        1)
  1426.  
  1427.  
  1428. //////////////////////////////////////////////////////////////////////
  1429. // resource definitions
  1430. #define        (kMaxResourceElevation,            3)
  1431. #define        (kResourceToEdgeDistance,        1)
  1432. #define        (kResourceToWaterDistance,        1)
  1433.  
  1434. #define        (kAnimalPerPlayer,            0)
  1435. #define        (kAnimalPerNeutral,            0)
  1436.  
  1437. #define        (kBerryPerPlayer,                1)
  1438. #define        (kBerryPerNeutral,            0)
  1439.  
  1440. #define        (kFishPerPlayer,                0)
  1441. #define        (kFishPerNeutral,                24)
  1442.  
  1443. #define        (kGoldPerPlayer,                1)
  1444. #define        (kGoldPerNeutral,                5)
  1445.  
  1446. #define        (kOilPerPlayer,                0)
  1447. #define        (kOilPerNeutral,                0)
  1448.  
  1449. #define        (kSteelPerPlayer,                1)
  1450. #define        (kSteelPerNeutral,            5)
  1451.  
  1452. #define        (kStonePerPlayer,                1)
  1453. #define        (kStonePerNeutral,            2)
  1454.  
  1455. #define        (kTreePerPlayer,                0)
  1456. #define        (kTreePerNeutral,                0)
  1457.  
  1458.  
  1459. //////////////////////////////////////////////////////////////////////
  1460. // forest definitions
  1461. #define        (kForestFreeRadius,            4.0)
  1462. #define        (kForestsPerPlayer,            1)
  1463. #define        (kForestChaosLevel,            0.1)
  1464. #define        (kMaxClumpsPerForest,              2)
  1465.  
  1466.  
  1467. #elif Is16Players
  1468. //////////////////////////////////////////////////////////////////////
  1469. // 16 PLAYERS...
  1470. //////////////////////////////////////////////////////////////////////
  1471.  
  1472. //////////////////////////////////////////////////////////////////////
  1473. // terrain definitions
  1474. #define        (kMinIntElevation,            -10)
  1475. #define        (kMaxIntElevation,            10)
  1476. #define        (kElevationScale,                0.99)
  1477. #define        (kPercentLand,                Between(.88, .88))
  1478. #define        (kWaterBorder,                0)
  1479. #define        (kHeightMapChaos,                Between(8, 15))
  1480.  
  1481. #define        (kMinimumStartPositionToMapEdge    1)
  1482. #define        (kOuterPushFromMapCenter        10)
  1483. #define        (kInnerPushFromMapCenter         0)                                            
  1484. //////////////////////////////////////////////////////////////////////
  1485. // player definitions
  1486. #define        (kMaxAngleBetweenTeamMembers,        30.0)
  1487. #define        (kPlayerInnerRadius,            0.9)
  1488. #define        (kPlayerOuterRadius,            0.999)
  1489. #define        (kPlayerOptimalFactor,            Between(0.5, 0.8))
  1490. #define        (kPlayerPercentFlat,            Between(0.9, 0.9))
  1491. #define        (kPlayerLandChaos,            0.8)
  1492. #define        (kPlayerLandClumps,            1)
  1493. #define        (kPlayerFlatChaos,            0.8)
  1494. #define        (kPlayerFlatClumps,            2)
  1495. #define        (kPlayerTreePercentage,            0.1)
  1496.  
  1497.  
  1498. //////////////////////////////////////////////////////////////////////
  1499. // inner neutral definitions
  1500. #define        (kNeutralInnerRadius,            0.45)
  1501. #define        (kNeutralOuterRadius,            0.45)
  1502. #define        (kNeutralOptimalFactor,            0.7)
  1503. #define        (kNumInnerNeutrals,            Between(0, 0))
  1504. #define        (kInnerNeutralPercentLand,        0.08)
  1505. #define        (kInnerNeutralPercentFlat,        0.9)
  1506. #define        (kInnerNeutralTreePercentage,          0.2)
  1507. #define        (kInnerNeutralLandChaos,        0.9)
  1508. #define        (kInnerNeutralLandClumps,        Between(1, 1))
  1509. #define        (kInnerNeutralFlatChaos,        0.8)
  1510. #define        (kInnerNeutralFlatClumps,        1)
  1511.  
  1512.  
  1513. //////////////////////////////////////////////////////////////////////
  1514. // outer neutral definitions
  1515. #define        (kNumOuterNeutrals,            7)
  1516. #define        (kOuterNeutralPercentLand,        0.3)
  1517. #define        (kOuterNeutralPercentFlat,        0.9)
  1518. #define        (kOuterNeutralTreePercentage,          0.25)
  1519. #define        (kOuterNeutralLandChaos,        0.8)
  1520. #define        (kOuterNeutralLandClumps,        2)
  1521. #define        (kOuterNeutralFlatChaos,        0.8)
  1522. #define        (kOuterNeutralFlatClumps,        1)
  1523.  
  1524.  
  1525. //////////////////////////////////////////////////////////////////////
  1526. // resource definitions
  1527. #define        (kMaxResourceElevation,            3)
  1528. #define        (kResourceToEdgeDistance,        1)
  1529. #define        (kResourceToWaterDistance,        1)
  1530.  
  1531. #define        (kAnimalPerPlayer,            0)
  1532. #define        (kAnimalPerNeutral,            0)
  1533.  
  1534. #define        (kBerryPerPlayer,                1)
  1535. #define        (kBerryPerNeutral,            0)
  1536.  
  1537. #define        (kFishPerPlayer,                0)
  1538. #define        (kFishPerNeutral,                24)
  1539.  
  1540. #define        (kGoldPerPlayer,                1)
  1541. #define        (kGoldPerNeutral,                5)
  1542.  
  1543. #define        (kOilPerPlayer,                0)
  1544. #define        (kOilPerNeutral,                0)
  1545.  
  1546. #define        (kSteelPerPlayer,                1)
  1547. #define        (kSteelPerNeutral,            5)
  1548.  
  1549. #define        (kStonePerPlayer,                1)
  1550. #define        (kStonePerNeutral,            2)
  1551.  
  1552. #define        (kTreePerPlayer,                0)
  1553. #define        (kTreePerNeutral,                0)
  1554.  
  1555.  
  1556. //////////////////////////////////////////////////////////////////////
  1557. // forest definitions
  1558. #define        (kForestFreeRadius,            4.0)
  1559. #define        (kForestsPerPlayer,            1)
  1560. #define        (kForestChaosLevel,            0.1)
  1561. #define        (kMaxClumpsPerForest,              2)
  1562.  
  1563.  
  1564. //////////////////////////////////////////////////////////////////////
  1565. // End of if...elif... command
  1566. #endif
  1567.  
  1568.  
  1569. #endif        // NOTDEFINED(CONTINENTAL_TINY_RMV)